﻿/*
SINACOR - BMF&Bovespa
Arquivo: DivergenciaCentralDepositaria.cs
Criado em: 01-abr-2010 18:07:53
Arquiteto Responsável: WGeneroso.prg
*/
using System;
using System.Collections.Generic;
using System.Text;
using Sinacor.Infra.Service.Common;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Service.ExceptionHandling;
using Sinacor.Infra.Service.Validation;
using Sinacor.Infra.Service.Security.Authorization;
using System.Linq;


namespace Sinacor.Servico.Bovespa.Alocacao.BusinessLogic
{
    public class DivergenciaCentralDepositaria : BaseBusinessLogic
    {
        #region Atributos

        private int _erroObjetoNulo = 109606;
        private int _erroPermissaoAcesso = 109616;

        #endregion

        #region Propriedades

        public int ErroObjetoNulo
        {
            get { return _erroObjetoNulo; }
            set { _erroObjetoNulo = value; }
        }

        public int ErroPermissaoAcesso
        {
            get { return _erroPermissaoAcesso; }
            set { _erroPermissaoAcesso = value; }
        }

        #endregion

        #region Construtor 

        public DivergenciaCentralDepositaria() : base()
        {
        }

        #endregion 

        #region Métodos

        #region ConsultarDivergenciasCentralDepositaria
        /// <summary>
        /// Consulta lista de divergencias de alocações com a central depositária
        /// </summary>
        /// <param name="entity"></param>
        public List<BusinessEntity.DivergenciaCentralDepositaria> ConsultarDivergenciasCentralDepositaria(BusinessEntity.Parameter.FiltroDivergenciaCentralDepositaria entity)
        {
            if (VerificarUsuarioOperador())
            {
                if (entity != null)
                {
                    SinacorValidation validation = new SinacorValidation();
                    validation.Validate<BusinessEntity.Parameter.FiltroDivergenciaCentralDepositaria>(entity);

                    ResourceAccess.DivergenciaCentralDepositaria resource = new ResourceAccess.DivergenciaCentralDepositaria();
                    List<BusinessEntity.DivergenciaCentralDepositaria> retorno = new List<Sinacor.Servico.Bovespa.Alocacao.BusinessEntity.DivergenciaCentralDepositaria>();

                    retorno = resource.ConsultarDivergenciasCentralDepositaria(entity);

                    return retorno;

                }
                else { throw new BusinessException(ErroObjetoNulo); }
            }
            else { throw new BusinessException(ErroPermissaoAcesso); }
        }
        #endregion

        #region ExecutarConciliacaoCentralDepositaria
        /// <summary>
        /// Executa a conciliação das divergências de alocação com a central depositária.
        /// </summary>
        /// <param name="entity"></param>
        public void ExecutarConciliacaoCentralDepositaria(BusinessEntity.Parameter.FiltroDivergenciaCentralDepositaria entity)
        {
            if (VerificarUsuarioOperador())
            {
                if (entity != null)
                {
                    SinacorValidation validation = new SinacorValidation();
                    validation.Validate<BusinessEntity.Parameter.FiltroDivergenciaCentralDepositaria>(entity);

                    ResourceAccess.DivergenciaCentralDepositaria resource = new ResourceAccess.DivergenciaCentralDepositaria();
                    BusinessEntity.Resultado resultado = new BusinessEntity.Resultado();

                    resultado = resource.ExecutarConciliacaoCentralDepositaria(entity);

                    if (resultado.Sucesso == false)
                    {
                        if (resultado.CodigoErro == -1) { throw new BusinessException(109669); }
                        else { this.TratarExcecoes(resultado); }
                    }
                }
                else { throw new BusinessException(ErroObjetoNulo); }
            }
            else { throw new BusinessException(ErroPermissaoAcesso); }
        }
        #endregion

        #region ObterNalcValido
        /// <summary>
        /// Obtem o Nalc válido.
        /// </summary>
        /// <param name="entity"></param>
        public BusinessEntity.NalcValido ObterNalcValido(BusinessEntity.Parameter.FiltroNalc entity)
        {
            if (VerificarUsuarioOperador())
            {
                if (entity != null)
                {
                    SinacorValidation validation = new SinacorValidation();
                    validation.Validate<BusinessEntity.Parameter.FiltroNalc>(entity);

                    BusinessEntity.Nalc nalc = new BusinessEntity.Nalc();
                    ResourceAccess.DivergenciaCentralDepositaria resource = new ResourceAccess.DivergenciaCentralDepositaria();

                    nalc = resource.ObterNalc(entity);
                    if (nalc != null)
                    {
                        if (nalc.Quantidade == 4)
                        {
                            return new BusinessEntity.NalcValido() { Valor = nalc.DataMensagem.ToString("dd-MM-yyyy HH:mm:ss") };
                        }
                        else { return new BusinessEntity.NalcValido(); }
                    }
                    else { return null; }
                }
                else { throw new BusinessException(ErroObjetoNulo); }
            }
            else { throw new BusinessException(ErroPermissaoAcesso); }
        }
        #endregion

        #region ReenviarMensagemDivergenciaCentralDepositaria
        /// <summary>
        /// Reenvia mensagem de divergência na alocação para central depositaria.
        /// </summary>
        /// <param name="entity"></param>
        public void ReenviarMensagemDivergenciaCentralDepositaria(BusinessEntity.DivergenciaCentralDepositaria entity)
        {
            if (VerificarUsuarioOperador())
            {
                if (entity != null)
                {
                    entity.CodigoUsuario = AuthorizationContext.Current.UserId;
                    SinacorValidation validation = new SinacorValidation();
                    validation.Validate<BusinessEntity.DivergenciaCentralDepositaria>(entity);

                    ResourceAccess.DivergenciaCentralDepositaria resource = new ResourceAccess.DivergenciaCentralDepositaria();
                    BusinessEntity.Resultado resultado = new BusinessEntity.Resultado();

                    resultado = resource.ReenviarMensagemDivergenciaCentralDepositaria(entity);

                    if (resultado.Sucesso == false)
                    {
                        if (resultado.CodigoErro == -1) 
                        { 
                            throw new BusinessException(109669); 
                        }
                        else 
                        { 
                            this.TratarExcecoes(resultado); 
                        }
                    }
                }
                else 
                { 
                    throw new BusinessException(ErroObjetoNulo); 
                }
            }
            else 
            { 
                throw new BusinessException(ErroPermissaoAcesso); 
            }
        }
        #endregion

        #region ReenviarMensagensDivergenciasCentralDepositaria
        /// <summary>
        /// Reenvia lista de mensagens de divergências de alocações de negócios na central
        /// depositária
        /// </summary>
        /// <param name="entityList"></param>
        public void ReenviarMensagensDivergenciasCentralDepositaria(List<BusinessEntity.DivergenciaCentralDepositaria> entityList)
        {
            if (entityList != null)
            {
                var listaDivergencias = (
                    from divergencia in entityList
                    where divergencia.IndicadorCiencia == true
                    select divergencia
                    );
                foreach (BusinessEntity.DivergenciaCentralDepositaria divergencia in listaDivergencias)
                { ReenviarMensagemDivergenciaCentralDepositaria(divergencia); }
            }
            else { throw new BusinessException(ErroObjetoNulo); }

        }
        #endregion

        #region TratarExcecoes
        /// <summary>
        /// Trata exceções geradas pelo Oracle
        /// </summary>
        /// <param name="resultado"></param>
        private void TratarExcecoes(BusinessEntity.Resultado resultado)
        {
            if (string.IsNullOrEmpty(resultado.Argumentos.ToString()))
            {
                throw new BusinessException(resultado.CodigoErro);
            }
            else
            {
                List<Object> _params = ErrorMessage.ConvertXmlArgumentsToParameters(resultado.Argumentos);

                if (_params != null)
                {
                    throw new BusinessException(resultado.CodigoErro, _params.ToArray());
                }
                else { throw new BusinessException(resultado.CodigoErro); }
            }
        }
        #endregion

        #region VerificarUsuarioOperador
        /// <summary>
        /// Verificar se o usuário está cadastrado como operador.
        /// </summary>
        private bool VerificarUsuarioOperador()
        {
            List<Operador.BusinessEntity.Operador> listaOperadores = null;
            Operador.BusinessLogic.Operador blOperador = new Sinacor.Servico.Bovespa.Operador.BusinessLogic.Operador();
            listaOperadores = blOperador.ConsultarOperadores(new Operador.BusinessEntity.Parameter.FiltroOperador { CodigoOperador = AuthorizationContext.Current.UserId });

            if (listaOperadores.Count > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        #endregion

        #endregion
    }

}